package cn.rkylin.oms.goods.service;

import java.math.BigDecimal;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.github.pagehelper.PageInfo;

import cn.rkylin.apollo.common.util.HttpUtils;
import cn.rkylin.core.ApolloMap;
import cn.rkylin.core.IDataBaseFactory;
import cn.rkylin.core.service.ApolloService;
import cn.rkylin.oms.common.consts.YesNoConst;
import cn.rkylin.oms.goods.dao.IGoodsDAO;
import cn.rkylin.oms.goods.dao.IMdmSkuDAO;
import cn.rkylin.oms.goods.dao.ISkuStockDAO;
import cn.rkylin.oms.goods.domain.SkuStock;
import cn.rkylin.oms.goods.util.SnOpenableValidator;
import cn.rkylin.oms.goods.vo.CategoryActionVO;
import cn.rkylin.oms.goods.vo.Goods;
import cn.rkylin.oms.goods.vo.GoodsInfoVO;
import cn.rkylin.oms.goods.vo.GoodsSku;
import cn.rkylin.oms.goods.vo.GoodsSkuVO;
import cn.rkylin.oms.goods.vo.GoodsVO;
import cn.rkylin.oms.goods.vo.MdmGetVO;
import cn.rkylin.oms.goods.vo.MdmSkuVO;
import cn.rkylin.oms.goods.vo.PrjSkuVO;
import cn.rkylin.oms.goods.vo.SkuStockVO;
import cn.rkylin.oms.item.dao.IItemDAO;
import cn.rkylin.oms.item.domain.SkuGroup;
import cn.rkylin.oms.item.vo.SkuVO;

/**
 * 系统商品管理服务实现
 *
 * @author wangxing
 * @version 1.0.0
 * @created 2017-7-5
 */

@Service("goodsService")
public class GoodsServiceImpl extends ApolloService implements IGoodsService {

    @Value("${mdm.server.url}")
    private String mdmServerUrl;

    @Value("${mdm.server.security}")
    private String mdmServerSecurity;

    @Value("${mdm.server.appId}")
    private String mdmServerAppId;

    /**
     * 系统商品数据访问
     */
    @Autowired
    private IGoodsDAO goodsDAO;

    @Autowired
    private IMdmSkuDAO mdmSkuDAO;

    /**
     * 平台商品数据访问
     */
    @Autowired
    private IItemDAO itemDAO;

    @Autowired
    private ISkuStockDAO skuStockDAO;

    @Autowired
    private IDataBaseFactory dao;

    @Autowired
    private SnOpenableValidator snOpenableValidator;

    public IGoodsDAO getGoodsDAO() {
        return goodsDAO;
    }

    public void setGoodsDAO(IGoodsDAO goodsDAO) {
        this.goodsDAO = goodsDAO;
    }

    /**
     * 系统商品服务层
     */
    @Autowired
    private IGoodsCategoryService goodsCategoryService;

    /**
     * 构造函数
     */
    public GoodsServiceImpl() {

    }

    /**
     * 新增系统商品，校验商品商家编码项目内是否重复
     *
     * @param vo
     * @return
     */
    private boolean checkGoodsCode(PrjSkuVO vo) {
        boolean result = false;
        Map<String, String> reqMap = new HashMap<String, String>();
        reqMap.put("goodsCode", vo.getGoodsCode());
        reqMap.put("prjId", vo.getPrjId());
        try {
            List<PrjSkuVO> list = dao.findList("selectGoodsCodeByPrjId", reqMap);
            if (list == null || list.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 新增系统商品，新增规格，校验商家编码项目内是否重复
     *
     * @param vo
     * @return
     */
    private boolean checkGoodsSkuCode(PrjSkuVO vo) {
        boolean result = false;
        Map<String, String> reqMap = new HashMap<String, String>();
        reqMap.put("skuCode", vo.getSkuCode());
        reqMap.put("prjId", vo.getPrjId());
        try {
            List<PrjSkuVO> list = dao.findList("selectGoodsSkuCodeByPrjId", reqMap);
            if (list == null || list.size() <= 0) {
                result = true;
            } else {
                if (vo.getListSkuId() != null && vo.getListSkuId().size() > 0) {
                    for (int i = list.size() - 1; i >= 0; i--) {
                        for (int j = 0; j < vo.getListSkuId().size(); j++) {
                            if (list.get(i).getSkuId().equals(vo.getListSkuId().get(j))) {
                                list.remove(i);
                            }
                        }
                    }
                }
                if (list.size() <= 0) {
                    result = true;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 校验系统规格条码项目内不重复
     *
     * @param vo
     * @return
     */
    private boolean checkSkuBarCode(GoodsSku vo, String enID, String prjId) {
        boolean result = true;
        Map<String, String> reqMap = new HashMap<String, String>();
        reqMap.put("prjId", prjId);
        try {
            List<PrjSkuVO> list = dao.findList("selectGoodsSkuCodeByPrjId", reqMap);
            if (list == null || list.size() <= 0) {
                result = true;
            } else {
                for (int i = 0; i < list.size(); i++) {
                    if (list.get(i).getSkuId().equals(vo.getId())) {
                        continue;
                    }
                    List<GoodsSkuVO> listGoodsSku = dao.findList("selectByPrimaryKeyGoodsSku", list.get(i).getSkuId());
                    if (listGoodsSku != null && listGoodsSku.size() > 0) {
                        if (vo.getBar().equals(listGoodsSku.get(0).getBarCode())) {
                            return false;
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    private boolean checkSkuBarCode(List<String> listBar, List<String> listBarId) {
        boolean result = false;
        // Map<String, List<String>> reqMap = new HashMap<String,
        // List<String>>();
        // reqMap.put("listBar",listBar);
        // reqMap.put("listBarId",listBarId);
        GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
        goodsSkuVO.setListBar(listBar);
        goodsSkuVO.setListBarId(listBarId);
        try {
            List<GoodsSku> goodsSkuVOList = dao.find("selectByGoodsSkuBarCodeS", goodsSkuVO);
            if (goodsSkuVOList == null || goodsSkuVOList.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 校验系统规格在其他项目是否存在
     *
     * @param vo
     * @return
     */
    private boolean checkPrjSku(PrjSkuVO vo) {
        boolean result = false;
        Map<String, String> reqMap = new HashMap<String, String>();
        reqMap.put("prjId", vo.getPrjId());
        reqMap.put("skuId", vo.getSkuId());
        try {
            List<PrjSkuVO> list = dao.findList("selectListDifferentPrj", reqMap);
            if (list == null || list.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 校验规格是否有库存
     *
     * @param vo
     * @return
     */
    private boolean checkSkuStock(SkuStock vo) {
        boolean result = false;
        Map<String, String> reqMap = new HashMap<String, String>();
        reqMap.put("skuId", vo.getSkuId());
        try {
            List<PrjSkuVO> list = dao.findList("selectListDifferentSkuStock", reqMap);
            if (list == null || list.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 方法复写 根据查询条件获取商品的库存信息.
     *
     * @see cn.rkylin.oms.goods.service.IGoodsService#getSkuStockList(cn.rkylin.oms.goods.vo.SkuStockVO)
     */
    @Override
    public List<SkuStock> getSkuStockList(SkuStockVO skuStockVO) throws Exception {
        return skuStockDAO.getGoodsSkuStorage(skuStockVO);

    }

    /**
     * 校验规格是否已经被平台商品所关联
     *
     * @param vo
     * @return
     */
    private boolean checkEcSku(SkuVO vo) {
        boolean result = false;
        try {
            List<SkuVO> resultList = dao.find("selectSkuByPrimaryKey", vo.getEcSkuId());
            if (resultList == null || resultList.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 校验规格是否已经被平台商品设置为组合商品
     *
     * @param vo
     * @return
     */
    private boolean checkEcSkuGroup(SkuGroup vo) {
        boolean result = false;
        try {
            List<SkuGroup> resultList = dao.find("selectSkuGroupBySkuId", vo.getSkuId());
            if (resultList == null || resultList.size() <= 0) {
                result = true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 系统商品的画面VO检查
     *
     * @param goodsInfo
     * @return
     */
    private Map<String, String> checkGoodesInfo(GoodsInfoVO goodsInfo, Map<String, String> map) throws Exception {
        Map<String, String> result = new HashMap<String, String>();
        // GoodsInfoVO是空
        if (goodsInfo == null) {
            result.put("isOk", "n");
            result.put("errorMessage", "系统商品VO为空");
            return result;
        }
        // GoodsInfoVO中的系统商品VO是空
        if ("insert".equals(goodsInfo.getAction()) && goodsInfo.getGoods() == null) {
            result.put("isOk", "n");
            result.put("errorMessage", "系统商品为空");
            return result;
        }

        // 检查系统商品
        Goods goods = goodsInfo.getGoods();

        // 商品名称为空
        if (("insert".equals(goodsInfo.getAction()) || "update".equals(goodsInfo.getAction())) && goods.getGoodName() == null) {
            result.put("isOk", "n");
            result.put("errorMessage", "商品名称为空");
            return result;
        }

        // 新增系统商品及规格的校验
        if ("insert".equals(goodsInfo.getAction())) {
            // 商品商家编码为空
            if (goods.getGoodCode() == null) {
                result.put("isOk", "n");
                result.put("errorMessage", "商品商家编码为空");
                return result;
            }
            // 校验规格条数不为0
            List<GoodsSku> listSku = goodsInfo.getArrSku();
            if (listSku == null || listSku.size() <= 0) {
                result.put("isOk", "n");
                result.put("errorMessage", "至少添加一条规格信息");
                return result;
            }
            // 同一项目商品商家编码不能重复
            PrjSkuVO goodsvo = new PrjSkuVO();
            goodsvo.setPrjId(map.get("prjId"));
            goodsvo.setGoodsCode(goods.getGoodCode());
            if (!checkGoodsCode(goodsvo)) {
                result.put("isOk", "n");
                result.put("errorMessage", "同一项目商品商家编码不能重复");
                return result;
            }

            // 规格校验开始------------------------------------------------------
            List<GoodsSku> list = goodsInfo.getArrSku();
            if (list != null && list.size() > 0) {
                for (int i = 0; i < list.size(); i++) {
                    GoodsSku goodsSku = list.get(i);
                    // 1、判断规格的商家编码是否在同一项目下重复
                    PrjSkuVO vo = new PrjSkuVO();
                    vo.setPrjId(map.get("prjId"));
                    vo.setSkuCode(goodsSku.getSkuCode());
                    if (!checkGoodsSkuCode(vo)) {
                        result.put("isOk", "n");
                        result.put("errorMessage", "同一项目规格商家编码不能重复");
                        return result;
                    }
                    // 2、判断规格的条码是否在同一项目下重复
                    if (StringUtils.isNotBlank(goodsSku.getBar())) {
                        GoodsSku sku = new GoodsSku();
                        sku.setBar(goodsSku.getBar());
                        sku.setId(goodsSku.getId());
                        if (!checkSkuBarCode(sku, map.get("entId"), map.get("prjId"))) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "规格条码项目内不允许重复");
                            return result;
                        }
                    }

                    // 3、判断当前画面中是否有重复的规格商家编码
                    for (int j = 0; j < list.size(); j++) {
                        if (i == j) {
                            continue;
                        }
                        GoodsSku goodsSku2 = list.get(j);
                        // 当前画面中规格商家编码重复校验
                        if (goodsSku.getSkuCode().equals(goodsSku2.getSkuCode())) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "规格列表中存在相同商家编码");
                            return result;
                        }
                        // 当前画面中条码重复校验
                        if (StringUtils.isNotBlank(goodsSku.getBar()) && StringUtils.isNotBlank(goodsSku2.getBar())
                                && goodsSku.getBar().equals(goodsSku2.getBar())) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "规格条码项目内不允许重复");
                            return result;
                        }
                    }
                }
            }
        } else if ("update".equals(goodsInfo.getAction())) {// 修改系统商品及规格的校验
            List<GoodsSku> list = goodsInfo.getArrSku();
            if (list != null) {
                List<String> listSkuId = new ArrayList<String>();
                List<String> listBar = new ArrayList<String>();
                List<String> listBarId = new ArrayList<String>();
                for (int i = list.size() - 1; i >= 0; i--) {
                    GoodsSku goodsSku = list.get(i);
                    // 修改商品时，新增了规格的校验
                    if ("insert".equals(goodsSku.getAction())) {
                        // 1、判断规格的商家编码是否在同一项目下重复
                        PrjSkuVO vo = new PrjSkuVO();
                        vo.setPrjId(map.get("prjId"));
                        vo.setSkuCode(goodsSku.getSkuCode());
                        vo.setListSkuId(listSkuId);
                        if (!checkGoodsSkuCode(vo)) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "同一项目规格商家编码不能重复");
                            return result;
                        }
                        // 2、判断规格的条码是否在同一项目下重复
                        if (StringUtils.isNotBlank(goodsSku.getBar())) {
                            GoodsSku sku = new GoodsSku();
                            sku.setBar(goodsSku.getBar());
                            sku.setId(goodsSku.getId());
                            if (!checkSkuBarCode(sku, map.get("entId"), map.get("prjId"))) {
                                result.put("isOk", "n");
                                result.put("errorMessage", "规格条码项目内不允许重复");
                                return result;
                            }
                        }
                    } else if ("update".equals(goodsSku.getAction())) {
                        // 判断规格的条码是否在同一项目下重复
                        if (StringUtils.isNotBlank(goodsSku.getBar())) {
                            for (int j = 0; j < list.size(); j++) {
                                if (i == j) {
                                    continue;
                                }

                                GoodsSku goodsSku2 = list.get(j);

                                // 当前画面中条码重复校验
                                if (StringUtils.isNotBlank(goodsSku.getBar()) && StringUtils.isNotBlank(goodsSku2.getBar())
                                        && goodsSku.getBar().equals(goodsSku2.getBar())) {
                                    result.put("isOk", "n");
                                    result.put("errorMessage", "规格条码项目内不允许重复");
                                    return result;
                                }
                                listBar.add(goodsSku.getBar());
                                listBarId.add(goodsSku.getId());
                            }

                            GoodsSku skuout = new GoodsSku();
                            skuout.setBar(goodsSku.getBar());
                            skuout.setId(goodsSku.getId());
                            if (!checkSkuBarCode(skuout, map.get("entId"), map.get("prjId"))) {
                                result.put("isOk", "n");
                                result.put("errorMessage", "规格条码项目内不允许重复");
                                return result;
                            }

                        }
                    } else if ("delete".equals(goodsSku.getAction())) {
                        // 修改商品时，删除了规格的校验
                        // 包括
                        // 平台规格表、平台规格组合商品表、系统商品库存表、商品库存比例表、系统订单明细表等
                        // oms_ec_sku
                        // oms_ec_sku_group
                        // oms_order_sku
                        // oms_refund_sku
                        // oms_resend_sku
                        // oms_return_sku
                        // oms_sales_promotion_constrain_goods
                        // oms_sales_promotion_gift
                        // oms_shiporder_sku
                        // oms_sku_stock
                        // oms_stockin_sku
                        // oms_stockout_sku
                        // qm_wms_sku

                        Map<String, String> mapRes = checkDelSku(goodsSku.getId());
                        if (null == mapRes) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "删除系统规格校验异常");
                            return result;
                        }
                        if (mapRes != null && mapRes.size() > 0) {
                            if (!"ok".equals(mapRes.get("error").toString())) {
                                result.put("isOk", "n");
                                result.put("errorMessage", mapRes.get("error").toString());
                                return result;
                            }
                        }
                    }

                    // 3、判断当前画面中是否有重复的规格商家编码
                    for (int j = 0; j < list.size(); j++) {
                        if (i == j) {
                            continue;
                        }
                        GoodsSku goodsSku2 = list.get(j);

                        // 当前画面中条码重复校验
                        if (StringUtils.isNotBlank(goodsSku.getBar()) && StringUtils.isNotBlank(goodsSku2.getBar())
                                && goodsSku.getBar().equals(goodsSku2.getBar())) {
                            result.put("isOk", "n");
                            result.put("errorMessage", "规格条码项目内不允许重复");
                            return result;
                        }
                    }
                    listSkuId.add(goodsSku.getId());
                }

                if (listBar != null && listBar.size() > 0 && listBarId != null && listBarId.size() > 0 && !checkSkuBarCode(listBar, listBarId)) {
                    result.put("isOk", "n");
                    result.put("errorMessage", "规格条码项目内不允许重复");
                    return result;
                }
            }
        } else if ("delete".equals(goodsInfo.getAction())) {// 删除系统商品及规格的校验

            Goods goodsInner = goodsInfo.getGoods();
            List<GoodsSkuVO> skuVOList = dao.findList("selectGoodsSkuListByGoodsId", goodsInner.getId());

            // List<GoodsSku> list = goodsInfo.getArrSku();
            if (skuVOList != null && skuVOList.size() > 0) {
                for (int i = 0; i < skuVOList.size(); i++) {
                    GoodsSkuVO goodsSku = skuVOList.get(i);

                    Map<String, String> mapRes = checkDelSku(goodsSku.getSkuId());
                    if (null == mapRes) {
                        result.put("isOk", "n");
                        result.put("errorMessage", "删除系统规格校验异常");
                        return result;
                    }
                    if (mapRes != null && mapRes.size() > 0) {
                        if (!"ok".equals(mapRes.get("error").toString())) {
                            result.put("isOk", "n");
                            result.put("errorMessage", mapRes.get("error").toString());
                            return result;
                        }
                    }
                }
            }
        }

        result.put("isOk", "y");
        result.put("errorMessage", "");
        return result;
    }

    /**
     * 校验 系统规格删除校验点
     * <p>
     * oms_ec_sku oms_ec_sku_group oms_order_sku oms_refund_sku oms_resend_sku
     * oms_return_sku oms_sales_promotion_constrain_goods
     * oms_sales_promotion_gift oms_shiporder_sku oms_sku_stock oms_stockin_sku
     * oms_stockout_sku qm_wms_sku
     *
     * @param skuId
     * @return
     */
    public Map<String, String> checkDelSku(String skuId) throws Exception {
        Map<String, String> mapRes = null;
        try {
            // 1、平台规格表
            List<HashMap> returnMapEcSku = goodsDAO.selectGoodsSkuInOthers("selectEcSkuBySkuId", skuId);
            if (returnMapEcSku != null && returnMapEcSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapEcSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经被平台商品所关联");
                    return mapRes;
                }
            }
            // 2、平台组合商品表
            List<HashMap> returnMapEcSkuGroup = goodsDAO.selectGoodsSkuInOthers("selectEcSkuGroupBySkuId", skuId);
            if (returnMapEcSkuGroup != null && returnMapEcSkuGroup.size() > 0) {
                int iCount = Integer.valueOf(returnMapEcSkuGroup.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经被平台商品设置成组合商品");
                    return mapRes;
                }
            }
            // 3、系统订单商品表
            List<HashMap> returnMapOrderSku = goodsDAO.selectGoodsSkuInOthers("selectOrderSkuBySkuId", skuId);
            if (returnMapOrderSku != null && returnMapOrderSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapOrderSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统订单");
                    return mapRes;
                }
            }
            // 4、系统退款单商品表
            List<HashMap> returnMapRefundSku = goodsDAO.selectGoodsSkuInOthers("selectRefundSkuBySkuId", skuId);
            if (returnMapRefundSku != null && returnMapRefundSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapRefundSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统退款单");
                    return mapRes;
                }
            }
            // 5、系统补发单商品表
            List<HashMap> returnMapResendSku = goodsDAO.selectGoodsSkuInOthers("selectResendSkuBySkuId", skuId);
            if (returnMapResendSku != null && returnMapResendSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapResendSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统补发单");
                    return mapRes;
                }
            }
            // 6、系统退货单商品表
            List<HashMap> returnMapReturnSku = goodsDAO.selectGoodsSkuInOthers("selectReturnSkuBySkuId", skuId);
            if (returnMapReturnSku != null && returnMapReturnSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapReturnSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统退货单");
                    return mapRes;
                }
            }
            // 7、促销管理限定商品表
            List<HashMap> returnMapSalesPromotionConstrainGoods = goodsDAO.selectGoodsSkuInOthers("selectSalesPromotionConstrainGoodsBySkuId",
                    skuId);
            if (returnMapSalesPromotionConstrainGoods != null && returnMapSalesPromotionConstrainGoods.size() > 0) {
                int iCount = Integer.valueOf(returnMapSalesPromotionConstrainGoods.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经被促销规则设置成限定商品");
                    return mapRes;
                }
            }
            // 8、促销规则赠送商品表
            List<HashMap> returnMapSalesPromotionGift = goodsDAO.selectGoodsSkuInOthers("selectSalesPromotionGiftBySkuId", skuId);
            if (returnMapSalesPromotionGift != null && returnMapSalesPromotionGift.size() > 0) {
                int iCount = Integer.valueOf(returnMapSalesPromotionGift.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经被促销规则设置成赠送商品");
                    return mapRes;
                }
            }
            // 9、系统发货单商品表
            List<HashMap> returnMapShiporderSku = goodsDAO.selectGoodsSkuInOthers("selectShiporderSkuBySkuId", skuId);
            if (returnMapShiporderSku != null && returnMapShiporderSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapShiporderSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统发货单");
                    return mapRes;
                }
            }

            // 11、系统入库单商品表
            List<HashMap> returnMapStockinSku = goodsDAO.selectGoodsSkuInOthers("selectStockinSkuBySkuId", skuId);
            if (returnMapStockinSku != null && returnMapStockinSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapStockinSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统入库单");
                    return mapRes;
                }
            }
            // 10、系统库存表
            List<HashMap> returnMapSkuStock = goodsDAO.selectGoodsSkuInOthers("selectSkuStockBySkuId", skuId);
            if (returnMapSkuStock != null && returnMapSkuStock.size() > 0) {
                int iCount = Integer.valueOf(returnMapSkuStock.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经存在库存信息");
                    return mapRes;
                }
            }

            // 12、系统出库单商品表
            List<HashMap> returnMapStockoutSku = goodsDAO.selectGoodsSkuInOthers("selectStockoutSkuBySkuId", skuId);
            if (returnMapStockoutSku != null && returnMapStockoutSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapStockoutSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经生成系统出库单");
                    return mapRes;
                }
            }
            // 13、奇门商品同步表
            List<HashMap> returnMapWmsSku = goodsDAO.selectGoodsSkuInOthers("selectWmsSkuBySkuId", skuId);
            if (returnMapWmsSku != null && returnMapWmsSku.size() > 0) {
                int iCount = Integer.valueOf(returnMapWmsSku.get(0).get("cot").toString());
                if (iCount > 0) {
                    mapRes = new HashedMap();
                    mapRes.put("error", "删除的规格已经同步的奇门仓库");
                    return mapRes;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            mapRes = null;
            return mapRes;
        }

        mapRes = new HashedMap();
        mapRes.put("error", "ok");

        return mapRes;
    }

    /**
     * 添加系统商品
     *
     * @param goods
     * @param entId
     * @return
     * @throws Exception
     */
    private String addGoods(Goods goods, String entId) throws Exception {
        GoodsVO goodsVO = new GoodsVO();
        String goodsId = java.util.UUID.randomUUID().toString().replaceAll("-", "");
        goodsVO.setGoodsCode(goods.getGoodCode());
        goodsVO.setGoodsName(goods.getGoodName());
        goodsVO.setCatgId(goods.getCatgId());
        if (!StringUtils.isBlank(goods.getCatgId())) {
            goodsVO.setCatgName(goods.getCatgName());
        }
        goodsVO.setRemark(goods.getRemark());
        goodsVO.setGoodsId(goodsId);
        goodsVO.setCreateTime(new Date());
        goodsVO.setUpdateTime(new Date());
        goodsVO.setEntId(entId);
        goodsVO.setIsSn(goods.getIsSn());
        goodsDAO.insert(goodsVO);
        return goodsId;
    }

    /**
     * 更新系统商品
     *
     * @param goods
     * @throws Exception
     */
    private void updateGoods(Goods goods) throws Exception {
        GoodsVO goodsVO = new GoodsVO();
        goodsVO.setUpdateTime(new Date());
        if (StringUtils.isNotBlank(goods.getCatgId())) {
            goodsVO.setCatgId(goods.getCatgId());
            goodsVO.setCatgName(goods.getCatgName());
        } else {
            goodsVO.setCatgId("");
            goodsVO.setCatgName("");
        }
        goodsVO.setRemark(goods.getRemark());
        goodsVO.setGoodsId(goods.getId());

        goodsDAO.update(goodsVO);
        setGoodsIsSn(goodsVO.getGoodsId(), goods.getIsSn());
    }

    /**
     * 删除系统商品
     *
     * @param goods
     * @throws Exception
     */
    private void deleteGoods(Goods goods) throws Exception {
        GoodsVO goodsVO = new GoodsVO();
        goodsVO.setUpdateTime(new Date());
        goodsVO.setGoodsId(goods.getId());
        goodsVO.setDeleted("y");
        goodsDAO.update(goodsVO);
    }

    /**
     * 添加系统规格
     *
     * @param goodsSku
     * @param goodsId
     * @param entId
     * @param goods
     * @return
     * @throws Exception
     */
    private String addGoodsSku(GoodsSku goodsSku, String goodsId, String entId, Goods goods) throws Exception {
        GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
        goodsSkuVO.setSkuCode(goodsSku.getSkuCode());
        goodsSkuVO.setSkuName(goodsSku.getSkuName());
        goodsSkuVO.setSalePrice((new BigDecimal(goodsSku.getPrice())));
        goodsSkuVO.setBarCode(goodsSku.getBar());
        // goodsSkuVO.setGiftsChk("是".equals(goodsSku.getGift()) ? "y" : "n");
        // goodsSkuVO.setVirtChk("是".equals(goodsSku.getVirt()) ? "y" : "n");
        goodsSkuVO.setGiftsYn("是".equals(goodsSku.getGift()) ? "y" : "n");
        goodsSkuVO.setVirtYn("是".equals(goodsSku.getVirt()) ? "y" : "n");
        goodsSkuVO.setSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
        goodsSkuVO.setGoodsId(goodsId);
        goodsSkuVO.setCreateTime(new Date());
        goodsSkuVO.setUpdateTime(new Date());
        goodsSkuVO.setEntId(entId);
        goodsSkuVO.setGoodsCode(goods.getGoodCode());
        goodsSkuVO.setGoodsName(goods.getGoodName());
        goodsSkuVO.setSkuMCode("1");// TODO 主数据编码
        goodsSkuVO.setStanPurcPrice((new BigDecimal(goodsSku.getStanPurcPrice())));
        goodsDAO.insertSku(goodsSkuVO);
        return goodsSkuVO.getSkuId();
    }

    /**
     * 修改系统规格
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updateGoodsSku(GoodsSku goodsSku) throws Exception {
        GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
        goodsSkuVO.setUpdateTime(new Date());
        goodsSkuVO.setSkuCode(goodsSku.getSkuCode());
        // goodsSkuVO.setSkuName(goodsSku.getSkuName());
        if (StringUtils.isNotBlank(goodsSku.getPrice())) {
            goodsSkuVO.setSalePrice(new BigDecimal(goodsSku.getPrice()));
        }
        goodsSkuVO.setBarCode(goodsSku.getBar());
        // goodsSkuVO.setGiftsChk("是".equals(goodsSku.getGift()) ? "y" : "n");
        // goodsSkuVO.setVirtChk("是".equals(goodsSku.getVirt()) ? "y" : "n");
        goodsSkuVO.setGiftsYn("是".equals(goodsSku.getGift()) ? "y" : "n");
        goodsSkuVO.setVirtYn("是".equals(goodsSku.getVirt()) ? "y" : "n");
        goodsSkuVO.setSkuId(goodsSku.getId());
        goodsSkuVO.setStanPurcPrice((new BigDecimal(goodsSku.getStanPurcPrice())));
        goodsDAO.updateSku(goodsSkuVO);
    }

    /**
     * 删除系统规格
     *
     * @param goodsSku
     * @throws Exception
     */
    private void deleteGoodsSku(GoodsSku goodsSku) throws Exception {
        GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
        goodsSkuVO.setUpdateTime(new Date());
        goodsSkuVO.setDeleted("y");
        goodsSkuVO.setSkuId(goodsSku.getId());
        goodsDAO.updateSku(goodsSkuVO);
    }

    /**
     * 更新系统规格中的商品信息
     *
     * @param goods
     * @throws Exception
     */
    private void updateGoodsSkuByGoodsId(Goods goods) throws Exception {
        GoodsSkuVO SkuVO = new GoodsSkuVO();
        SkuVO.setGoodsId(goods.getId());
        SkuVO.setGoodsName(goods.getGoodName());
        SkuVO.setUpdateTime(new Date());
        goodsDAO.updateGoodsSkuByGoodsId(SkuVO);
    }

    /**
     * 通过系统商品的ID删除所有其下的系统规格
     *
     * @param id
     * @throws Exception
     */
    private void deleteGoodsSkuByGoodId(String id) throws Exception {
        goodsDAO.deleteSkuByGoodsId(id);
    }

    /**
     * 添加系统规格和项目之间的关系数据
     *
     * @param map
     * @param goodsSku
     * @param goods
     * @throws Exception
     */
    private void addPrjSku(Map<String, String> map, GoodsSku goodsSku, Goods goods) throws Exception {
        PrjSkuVO prjSkuVO = new PrjSkuVO();
        prjSkuVO.setPrjSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
        prjSkuVO.setEntId(map.get("entId"));
        prjSkuVO.setPrjId(map.get("prjId"));
        prjSkuVO.setPrjName(map.get("prjName"));
        prjSkuVO.setSkuId(map.get("skuId"));
        prjSkuVO.setSkuCode(goodsSku.getSkuCode());
        prjSkuVO.setSkuName(goodsSku.getSkuName());
        prjSkuVO.setGoodsId(map.get("goodsId"));
        prjSkuVO.setGoodsCode(goods.getGoodCode());
        prjSkuVO.setGoodsName(goods.getGoodName());
        prjSkuVO.setEnable("y");
        prjSkuVO.setDeleted("n");
        prjSkuVO.setCreateTime(new Date());
        prjSkuVO.setUpdateTime(new Date());
        goodsDAO.insertPrjSku(prjSkuVO);
    }

    /**
     * 更新商品与项目关联表中的商品信息
     *
     * @param goods
     * @throws Exception
     */
    private void updatePrjSkuByGoodsId(Goods goods) throws Exception {
        PrjSkuVO prjSkuVO = new PrjSkuVO();
        prjSkuVO.setGoodsId(goods.getId());
        prjSkuVO.setGoodsName(goods.getGoodName());
        prjSkuVO.setUpdateTime(new Date());
        goodsDAO.updatePrjSkuByGoodsId(prjSkuVO);
    }

    /**
     * 更新规格与项目关联表中的规格信息
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updatePrjSkuByGoodsSkuId(GoodsSku goodsSku) throws Exception {
        PrjSkuVO prjSkuVO = new PrjSkuVO();
        prjSkuVO.setSkuId(goodsSku.getId());
        prjSkuVO.setSkuName(goodsSku.getSkuName());
        prjSkuVO.setUpdateTime(new Date());
        goodsDAO.updatePrjSkuByGoodsSkuId(prjSkuVO);
    }

    /**
     * 删除项目关联表中的规格
     *
     * @param goodsSku
     * @throws Exception
     */
    private void deletePrjSkuByGoodsSkuId(GoodsSku goodsSku) throws Exception {
        PrjSkuVO prjSkuVO = new PrjSkuVO();
        prjSkuVO.setSkuId(goodsSku.getId());
        prjSkuVO.setDeleted("y");
        prjSkuVO.setUpdateTime(new Date());
        goodsDAO.updatePrjSkuByGoodsSkuId(prjSkuVO);
    }

    /**
     * 删除项目关联表中规格信息通过商品ID
     *
     * @param goods
     * @throws Exception
     */
    private void deletePrjSkuByGoodsId(Goods goods) throws Exception {
        GoodsVO goodsVO = new GoodsVO();
        goodsVO.setUpdateTime(new Date());
        goodsVO.setGoodsId(goods.getId());
        goodsVO.setDeleted("y");
        goodsDAO.deletePrjSkuByGoodsId(goodsVO);
    }

    /**
     * 更新平台商品关联的系统商品信息
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updateEcSkuByGoodsSkuId(GoodsSku goodsSku) throws Exception {
        SkuVO skuVO = new SkuVO();
        skuVO.setSkuName(goodsSku.getSkuName());
        skuVO.setUpdateTime(new Date());
        skuVO.setSkuId(goodsSku.getId());
        itemDAO.updateEcSkuByGoodsSkuId(skuVO);
    }

    /**
     * 更新平台商品关联的系统商品信息商品
     *
     * @param goods
     * @throws Exception
     */
    private void updateEcSkuInforByGoodsId(Goods goods) throws Exception {
        SkuVO skuVO = new SkuVO();
        skuVO.setUpdateTime(new Date());
        skuVO.setGoodsName(goods.getGoodName());
        skuVO.setGoodsId(goods.getId());
        itemDAO.updateSkuInforbyGoodsId(skuVO);
    }

    /**
     * 更新平台商品设置的组合商品的系统商品信息
     *
     * @param goods
     * @throws Exception
     */
    private void updateEcSkuGroupByGoodsId(Goods goods) throws Exception {
        SkuGroup skuGroup = new SkuGroup();
        skuGroup.setUpdateTime(new Date());
        skuGroup.setGoodsName(goods.getGoodName());
        skuGroup.setGoodsId(goods.getId());
        itemDAO.updateSkuGroupInforbyGoodsId(skuGroup);
    }

    /**
     * 更新平台商品设置的组合商品的系统规格信息
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updateEcSkuGroupByGoodsSkuId(GoodsSku goodsSku) throws Exception {
        SkuGroup skuGroup = new SkuGroup();
        skuGroup.setUpdateTime(new Date());
        skuGroup.setSkuName(goodsSku.getSkuName());
        skuGroup.setSkuId(goodsSku.getId());
        itemDAO.updateSkuGroupbyGoodsId(skuGroup);
    }

    /**
     * 更新库存公式中的商品信息
     *
     * @param goods
     * @throws Exception
     */
    private void updateStockFmlaRatioStorbyGoodsId(Goods goods) throws Exception {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("goodsName", goods.getGoodName());
        params.put("updateTime", new Date());
        params.put("goodsId", goods.getId());
        // stockRuleDao.updateStockFmlaRatioStorbyGoodsId(params);
    }

    /**
     * 更新库存公式中的规格信息
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updateStockFmlaRatioStorbyGoodsSkuId(GoodsSku goodsSku) throws Exception {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("skuName", goodsSku.getSkuName());
        params.put("updateTime", new Date());
        params.put("skuId", goodsSku.getId());
        // stockRuleDao.updateStockFmlaRatioStorbyGoodsId(params);
    }

    /**
     * 更新库存信息表中的商品信息
     *
     * @param goods
     * @throws Exception
     */
    private void updateSkuStockByGoodsId(Goods goods) throws Exception {
        SkuStock skuStock = new SkuStock();
        skuStock.setGoodsId(goods.getId());
        skuStock.setGoodsName(goods.getGoodName());
        skuStock.setUpdateTime(new Date());
        skuStockDAO.updateByGoodsIdSkuStock(skuStock);
    }

    /**
     * 更新库存信息表中的规格信息
     *
     * @param goodsSku
     * @throws Exception
     */
    private void updateSkuStockByGoodsSkuId(GoodsSku goodsSku) throws Exception {
        SkuStock skuStock = new SkuStock();
        skuStock.setSkuId(goodsSku.getId());
        skuStock.setSkuName(goodsSku.getSkuName());
        skuStock.setUpdateTime(new Date());
        skuStockDAO.updateByGoodsIdSkuStock(skuStock);
    }

    /**
     * 处理数据集（系统商品以及规格）。
     *
     * @param goodsInfo
     * @return
     * @throws Exception
     */
    public Map<String, Object> modifyGoodsData(GoodsInfoVO goodsInfo, Map<String, String> map) throws Exception {
        Map<String, Object> result = new HashMap<String, Object>();

        // check 对于系统商品和系统规格的新增和修改，做校验
        Map<String, String> checkMap = checkGoodesInfo(goodsInfo, map);
        if ("n".equals(checkMap.get("isOk"))) {
            result.put("isOk", "n");
            result.put("count", "0");
            // TODO 这里的返回值没有按照规范编写，而且影响到其它调用的地方，需要一并修改，见ItemServiceImpl
            result.put("errorMessage", checkMap.get("errorMessage"));
            return result;
        }

        Goods goods = goodsInfo.getGoods();
        List<GoodsSku> list = goodsInfo.getArrSku();

        // 校验通过后，新增系统商品及系统规格
        if ("insert".equals(goodsInfo.getAction())) {
            // 追加goods数据
            String id = addGoods(goods, map.get("entId"));
            for (int i = 0; i < list.size(); i++) {
                GoodsSku goodsSku = list.get(i);
                // 追加goodsSku数据
                String skuId = addGoodsSku(goodsSku, id, map.get("entId"), goods);
                map.put("skuId", skuId);
                map.put("goodsId", id);
                // 追加prjSku数据
                addPrjSku(map, goodsSku, goods);
            }
        } else if ("update".equals(goodsInfo.getAction())) {
            if ("update".equals(goods.getAction())) {
                // 1、更新商品表(oms_goods)
                updateGoods(goods);

                // // 商品更新成功后同时需要更新:
                // // 2、系统规格表(oms_goods_sku)
                // updateGoodsSkuByGoodsId(goods);
                // // 3、项目商品关联表(oms_prj_sku)
                // updatePrjSkuByGoodsId(goods);
                // // 4、平台规格表(oms_ec_sku)、
                // updateEcSkuInforByGoodsId(goods);
                //
                // // 5、系统订单明细表(oms_order_goods) TODO
                // // 调用订单的controller更新订单明细上的商品信息。。。。。。。。。。。。。。。。。。。。TODO
                // // 6、系统商品库存表(oms_sku_stock)
                // // updateSkuStockByGoodsId(goods);
                // // 调用仓库的controller更新库存表上的商品信息。。。。。。。。。。。。。。。。。。。。
                // // 7、商品库存比例表中的商品信息(oms_stock_fmla_ratio_sku)
                // // updateStockFmlaRatioStorbyGoodsId(goods);
                // // 调用仓库的controller更新商品库存比例表上的商品信息。。。。。。。。。。。。。。。。。。。。
                // // 8、平台规格组合商品表的信息(oms_ec_sku_group)
                // updateEcSkuGroupByGoodsId(goods);
            }
            if (list != null) {
                for (int i = list.size() - 1; i >= 0; i--) {
                    GoodsSku goodsSku = list.get(i);
                    if ("insert".equals(goodsSku.getAction())) {
                        // 追加goodsSku数据
                        String skuId = addGoodsSku(goodsSku, goods.getId(), map.get("entId"), goods);
                        map.put("skuId", skuId);
                        map.put("goodsId", goods.getId());
                        // 追加prjSku数据
                        addPrjSku(map, goodsSku, goods);
                    } else if ("update".equals(goodsSku.getAction())) {
                        // 1、系统规格表(oms_goods_sku)
                        updateGoodsSku(goodsSku);
                        // // 2、项目商品关联表(oms_prj_sku)、
                        // updatePrjSkuByGoodsSkuId(goodsSku);
                        // // 3、平台规格表(oms_ec_sku)、
                        // updateEcSkuByGoodsSkuId(goodsSku);
                        //
                        // // 4、系统订单明细表(oms_order_goods) TODO
                        // //
                        // 调用订单的controller更新订单明细上的商品信息。。。。。。。。。。。。。。。。。。。。TODO
                        // // 5、系统商品库存表(oms_sku_stock)
                        // // updateSkuStockByGoodsSkuId(goodsSku);
                        // // 调用仓库的controller更新库存表上的商品信息。。。。。。。。。。。。。。。。。。。。
                        // // 6、商品库存比例表中的商品信息(oms_stock_fmla_ratio_sku)
                        // // updateStockFmlaRatioStorbyGoodsSkuId(goodsSku);
                        // // 调用仓库的controller更新商品库存比例表上的商品信息。。。。。。。。。。。。。。。。。。。。
                        // // 7、平台规格组合商品表的信息(oms_ec_sku_group)
                        // updateEcSkuGroupByGoodsSkuId(goodsSku);

                    } else if ("delete".equals(goodsSku.getAction())) {
                        // 1、逻辑删除系统规格
                        deleteGoodsSku(goodsSku);
                        // 2、逻辑删除系统规格与项目的关联关系
                        deletePrjSkuByGoodsSkuId(goodsSku);
                    }
                }
            }
        } else if ("delete".equals(goodsInfo.getAction())) {
            // 1、逻辑删除系统商品
            deleteGoods(goods);
            // 2、逻辑删除系统规格
            deleteGoodsSkuByGoodId(goods.getId());
            // 3、逻辑删除系统规格与项目的关联关系
            deletePrjSkuByGoodsId(goods);
        }
        result.put("isOk", "y");
        result.put("count", "1");
        // TODO 这里的返回值没有按照规范编写，而且影响到其它调用的地方，需要一并修改，见ItemServiceImpl
        result.put("errorMessage", "");
        return result;
    }

    /**
     * 查询系统商品
     *
     * @param page
     * @param rows
     * @param goodsVO
     * @return
     * @throws Exception
     */
    public PageInfo<GoodsVO> findByWhere(int page, int rows, GoodsVO goodsVO) throws Exception {
        PageInfo<GoodsVO> goodsVOList = findPage(page, rows, "pageSelectGoods", goodsVO);
        return goodsVOList;
    }

    // @Override

    /**
     * 查询系统规格
     *
     * @param goodsSkuVO
     * @return
     * @throws Exception
     */
    public List<GoodsSkuVO> findByWhere(GoodsSkuVO goodsSkuVO) throws Exception {
        List<GoodsSkuVO> goodsSkuVOList = findPage("pageSelectGoodsSku", goodsSkuVO);
        return goodsSkuVOList;
    }

    public PageInfo<GoodsSkuVO> findByWhere(int page, int length, GoodsSkuVO goodsSkuVO) throws Exception {
        PageInfo<GoodsSkuVO> goodsSkuVOList = findPage(page, length, "pageSelectGoodsSku", goodsSkuVO);
        return goodsSkuVOList;
    }

    /**
     * 新增系统商品
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int insertGoods(ApolloMap<String, Object> params) throws Exception {
        int r = dao.insert("insertGoods", params);
        return r;
    }

    /**
     * 修改系统商品
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int updateGoods(ApolloMap<String, Object> params) throws Exception {
        int r = dao.update("updateGoods", params);
        return r;
    }

    /**
     * 删除系统商品(逻辑删除)
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int deleteGoods(ApolloMap<String, Object> params) throws Exception {
        int r = dao.update("deleteGoods", params);
        return r;
    }

    /**
     * 新增系统规格
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int insertGoodsSku(ApolloMap<String, Object> params) throws Exception {
        int r = dao.insert("insertGoodsSku", params);
        return r;
    }

    /**
     * 修改系统规格
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int updateGoodsSku(ApolloMap<String, Object> params) throws Exception {
        int r = dao.update("updateGoodsSku", params);
        return r;
    }

    /**
     * 删除系统规格(逻辑删除)
     *
     * @param params
     * @return
     * @throws Exception
     */
    public int deleteGoodsSku(ApolloMap<String, Object> params) throws Exception {
        int r = dao.update("deleteGoodsSku", params);
        return r;
    }

    /**
     * 删除系统规格
     * 
     * @param skuId
     * @throws Exception
     */
    public void deleteGoodsSku(String skuId) throws Exception {
        GoodsSku goodsSku = new GoodsSku();
        goodsSku.setId(skuId);
        // 1、逻辑删除系统规格
        deleteGoodsSku(goodsSku);
        // 2、逻辑删除系统规格与项目的关联关系
        deletePrjSkuByGoodsSkuId(goodsSku);
    }

    @Override
    public List<GoodsSkuVO> getGoodsSkuByGoodsId(String goodsId) throws Exception {
        List<GoodsSkuVO> list = dao.findList("selectGoodsSkuListByGoodsId", goodsId);
        return list;
    }

    @Override
    @Transactional
    public GoodsVO getGoodsById(String goodsId) throws Exception {
        List<GoodsVO> list = dao.findList("selectGoodsByGoodsId", goodsId);
        if (list != null && list.size() > 0) {
            return list.get(0);
        }
        return null;
    }

    @Override
    public Map<String, Object> updateCategorybyGoodsIds(CategoryActionVO categoryActionVO) throws Exception {
        Map<String, Object> result = new HashMap<String, Object>();

        if (categoryActionVO == null) {
            result.put("isOk", "n");
            result.put("count", "0");
            result.put("errorMessage", "前端传递参数有问题");
            return result;
        }

        if (categoryActionVO.getGoodsId() == null || categoryActionVO.getGoodsId().length <= 0) {
            result.put("isOk", "n");
            result.put("count", "0");
            result.put("errorMessage", "没有选择系统商品");
            return result;
        }
        GoodsVO goodsVO = new GoodsVO();
        goodsVO.setCatgId(categoryActionVO.getCatgId());
        goodsVO.setCatgName(categoryActionVO.getCatgName());
        goodsVO.setUpdateTime(new Date());
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < categoryActionVO.getGoodsId().length; i++) {
            list.add(categoryActionVO.getGoodsId()[i]);
        }
        goodsVO.setListGoodsId(list);
        goodsDAO.updateCatgNameByCatgIds(goodsVO);
        result.put("isOk", "Y");
        result.put("count", categoryActionVO.getGoodsId().length);
        result.put("errorMessage", "");
        return result;
    }

    /**
     * 查询项目sku列表为采购入库单
     *
     * @param prjSkuVO
     *            项目sku VO
     * @throws Exception
     *             异常
     */
    public List<PrjSkuVO> selectPrjSkuListForStockIn(PrjSkuVO prjSkuVO) throws Exception {
        return goodsDAO.selectPrjSkuListForStockIn(prjSkuVO);
    }

    public List<PrjSkuVO> selectPrjSkuListForCainiao(PrjSkuVO prjSkuVO) throws Exception {
        return goodsDAO.selectPrjSkuListForCainiao(prjSkuVO);
    }

    /**
     * 查询仓库商品列表
     *
     * @param skuStockVO
     *            仓库商品VO
     * @throws Exception
     *             异常
     */
    public List<SkuStockVO> selectStockSkuList(SkuStockVO skuStockVO) throws Exception {
        return skuStockDAO.selectStockSkuList(skuStockVO);
    }

    @Override
    public cn.rkylin.oms.goods.domain.GoodsSku getGoodsSkuBySkuId(String skuId) throws Exception {
        return goodsDAO.getGoodsSkuBySkuId(skuId);
    }

    @Override
    public int selectCount(Map<String, Object> params) throws Exception {
        return goodsDAO.selectCount(params);
    }

    @Override
    public Map<String, Object> downLoadGoods(String entId, String mdm_code) throws Exception {
        Map<String, Object> map = downLoadGoods("1", 0, entId, mdm_code);
        return map;
    }

    private Map<String, Object> downLoadGoods(String page, int rows, String entId, String mdm_code) throws Exception {
        Map<String, Object> resultMap = new HashMap<String, Object>();
        String data = "{\"system_code\":\"ERP001\",\"page\":" + page + ",\"page_size\":\"1000\"}";
        String t = String.valueOf((new Date()).getTime());
        String sign = MD5(mdmServerSecurity + t + data);

        StringBuffer sb = new StringBuffer();
        sb.append(mdmServerUrl + "/api/mdm_goods_template_instance/query" + "?");
        sb.append("appId=" + mdmServerAppId);
        sb.append("&timestamp=" + t);
        sb.append("&sign=" + sign);
        sb.append("&system_code=ERP001&page=" + page + "&page_size=1000");
        if (StringUtils.isNotBlank(mdm_code)) {
            sb.append("&mdm_code=" + mdm_code);
        }

        String json = HttpUtils.sendByPost(sb.toString(), data);// HttpUtils.sendByGet(sb.toString(),
                                                                // null);
        System.out.println(json);

        MdmGetVO mdmGetVO = JSON.parseObject(json, MdmGetVO.class);
        List<String> listRecodesJson = JSON.parseArray(mdmGetVO.getResult().getData().getRecords(), String.class);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (mdmGetVO != null && "S1".equals(mdmGetVO.getStatus())) {
            if (mdmGetVO.getResult() != null && "Y1".equals(mdmGetVO.getResult().getStatus())) {
                if (listRecodesJson != null && listRecodesJson.size() > 0) {
                    Map<String, String> map = new HashMap<String, String>();
                    for (int i = 0; i < listRecodesJson.size(); i++) {
                        Map<String, Object> jsonMap = JSONObject.parseObject(listRecodesJson.get(i), new TypeReference<Map<String, Object>>() {
                        });
                        if (jsonMap != null) {

                            // MdmSku表数据处理
                            MdmSkuVO mdmSkuVO = new MdmSkuVO();
                            mdmSkuVO.setEntId(entId);
                            mdmSkuVO.setMdmCode((String) jsonMap.get("mdm_code"));
                            mdmSkuVO.setMdmResponse(listRecodesJson.get(i));
                            mdmSkuVO.setUpdateTime(new Date());
                            mdmSkuVO.setDeleted("n");

                            MdmSkuVO mdmSkuVOGet = mdmSkuDAO.getMdmSkuByMdmCode((String) jsonMap.get("mdm_code"));
                            if (mdmSkuVOGet != null) {
                                mdmSkuVO.setCreateTime(new Date());
                                mdmSkuDAO.update(mdmSkuVO);
                            } else {
                                mdmSkuDAO.insert(mdmSkuVO);
                            }

                            // Goods表处理
                            GoodsVO goodsVO = new GoodsVO();
                            // goods_id
                            goodsVO.setGoodsCode((String) jsonMap.get("goods_code"));
                            goodsVO.setGoodsName((String) jsonMap.get("goods_name"));
                            goodsVO.setEntId(entId);
                            goodsVO.setCatgId((String) jsonMap.get("goods_category_code"));
                            goodsVO.setCatgName(
                                    goodsCategoryService.getGoodsCategoryVO(entId, (String) jsonMap.get("goods_category_code")).getCatgName());
                            goodsVO.setDeleted("n");
                            goodsVO.setUpdateTime(new Date());
                            if (jsonMap.get("shelf_life") != null) {
                                goodsVO.setValidityDay((Integer) jsonMap.get("shelf_life"));
                            }
                            goodsVO.setIsBatch((String) jsonMap.get("batch_management_flag"));
                            goodsVO.setIsValidity((String) jsonMap.get("shelf_life_management_flag"));

                            String goodsId = java.util.UUID.randomUUID().toString().replaceAll("-", "");
                            List<GoodsVO> goodsVOList = findPage("selectGoodsByGoodsCodeEntId", goodsVO);
                            if (goodsVOList != null && goodsVOList.size() > 0) {
                                goodsId = goodsVOList.get(0).getGoodsId();
                                goodsVO.setGoodsId(goodsId);
                                goodsDAO.update(goodsVO);
                            } else {
                                goodsVO.setGoodsId(goodsId);
                                goodsVO.setCreateTime(new Date());
                                goodsDAO.insert(goodsVO);
                            }

                            // GoodsSku表处理
                            GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
                            goodsSkuVO.setSkuMCode((String) jsonMap.get("mdm_code"));
                            goodsSkuVO.setSkuCode((String) jsonMap.get("barcode"));
                            goodsSkuVO.setBarCode((String) jsonMap.get("barcode"));
                            goodsSkuVO.setSkuName((String) jsonMap.get("sku_name"));
                            goodsSkuVO.setGoodsId(goodsId);
                            goodsSkuVO.setGoodsCode((String) jsonMap.get("goods_code"));
                            goodsSkuVO.setGoodsName((String) jsonMap.get("goods_name"));
                            goodsSkuVO.setEntId(entId);
                            goodsSkuVO.setSalePrice((BigDecimal) jsonMap.get("retail_price"));
                            goodsSkuVO.setGiftsYn((String) jsonMap.get("gift_allowed_flag"));
                            goodsSkuVO.setVirtYn((String) jsonMap.get("virtual_goods_flag"));
                            goodsSkuVO.setRemark((String) jsonMap.get("remark"));
                            goodsSkuVO.setDeleted("n");
                            goodsSkuVO.setUpdateTime(new Date());
                            goodsSkuVO.setStanPurcPrice((BigDecimal) jsonMap.get("taxed_purchase_price"));

                            List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCodeEntId", goodsSkuVO);
                            if (goodsSkuVOList != null && goodsSkuVOList.size() > 0) {
                                goodsSkuVO.setSkuId(goodsSkuVOList.get(0).getSkuId());
                                goodsDAO.updateSku(goodsSkuVO);
                            } else {
                                goodsSkuVO.setSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                                goodsSkuVO.setCreateTime(new Date());
                                goodsDAO.insertSku(goodsSkuVO);
                            }
                        }
                    }
                    rows = rows + listRecodesJson.size();
                    if (Integer.valueOf(mdmGetVO.getResult().getData().getTotalCount()) - rows > 0) {
                        Map<String, Object> returnMap = downLoadGoods(String.valueOf(Integer.valueOf(page) + 1), rows, entId, mdm_code);
                        rows = rows + Integer.valueOf((String) returnMap.get("size"));
                        resultMap.put("msg", returnMap.get("msg"));
                    }
                }
            } else if (mdmGetVO.getResult() != null && "Y2".equals(mdmGetVO.getResult().getStatus())) {
                resultMap.put("size", "0");
                resultMap.put("msg", "参数错误");
            } else if (mdmGetVO.getResult() != null && "Y3".equals(mdmGetVO.getResult().getStatus())) {
                resultMap.put("size", "0");
                resultMap.put("msg", "唯一性校验失败");
            } else if (mdmGetVO.getResult() != null && "Y4".equals(mdmGetVO.getResult().getStatus())) {
                resultMap.put("size", "0");
                resultMap.put("msg", "数据状态异常");
            }
        } else if (mdmGetVO != null && "S2".equals(mdmGetVO.getStatus())) {
            resultMap.put("size", "0");
        } else if (mdmGetVO != null && "S3".equals(mdmGetVO.getStatus())) {
            resultMap.put("size", "0");
        } else if (mdmGetVO != null && "S4".equals(mdmGetVO.getStatus())) {
            resultMap.put("size", "0");
        } else {

        }
        if (mdmGetVO != null && resultMap.get("msg") == null) {
            resultMap.put("msg", mdmGetVO.getMessage());
        }
        resultMap.put("size", String.valueOf(rows));
        if (Integer.valueOf(mdmGetVO.getResult().getData().getTotalCount()) - rows > 0) {
            resultMap.put("success", "n");
        } else {
            resultMap.put("success", "y");
        }
        return resultMap;
    }

    private String MD5(String message) {
        String mess = message;
        char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        try {
            byte[] btInput = mess.getBytes("UTF-8");
            // 获得MD5摘要算法的 MessageDigest 对象
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            // 使用指定的字节更新摘要
            mdInst.update(btInput);
            // 获得密文
            byte[] md = mdInst.digest();
            // 把密文转换成十六进制的字符串形式
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i++) {
                byte byte0 = md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 北京主动推送商品数据
     * 
     * @param json
     * @param type
     * @param entId
     * @return
     * @throws Exception
     */
    public Object receiveGoods(String json, String type, String entId) throws Exception {
        List<String> listRecodesJson = JSON.parseArray(json, String.class);
        if (listRecodesJson != null && listRecodesJson.size() > 0) {
            for (int i = 0; i < listRecodesJson.size(); i++) {
                Map<String, Object> jsonMap = JSONObject.parseObject(listRecodesJson.get(i), new TypeReference<Map<String, Object>>() {
                });
                if (jsonMap != null) {
                    // MdmSku表数据处理
                    MdmSkuVO mdmSkuVO = new MdmSkuVO();
                    mdmSkuVO.setEntId(entId);
                    mdmSkuVO.setMdmCode((String) jsonMap.get("mdm_code"));
                    mdmSkuVO.setMdmResponse(listRecodesJson.get(i));
                    mdmSkuVO.setUpdateTime(new Date());
                    mdmSkuVO.setDeleted("n");

                    MdmSkuVO mdmSkuVOGet = mdmSkuDAO.getMdmSkuByMdmCode((String) jsonMap.get("mdm_code"));
                    if (mdmSkuVOGet != null) {
                        mdmSkuVO.setCreateTime(new Date());
                        mdmSkuDAO.update(mdmSkuVO);
                    } else {
                        mdmSkuDAO.insert(mdmSkuVO);
                    }

                    // Goods表处理
                    GoodsVO goodsVO = new GoodsVO();
                    // goods_id
                    goodsVO.setGoodsCode((String) jsonMap.get("goods_code"));
                    goodsVO.setGoodsName((String) jsonMap.get("goods_name"));
                    goodsVO.setEntId(entId);
                    goodsVO.setCatgId((String) jsonMap.get("goods_category_code"));
                    goodsVO.setCatgName(
                            goodsCategoryService.getGoodsCategoryVO(entId, (String) jsonMap.get("goods_category_code")).getCatgName());
                    goodsVO.setDeleted("n");
                    goodsVO.setUpdateTime(new Date());
                    if (jsonMap.get("shelf_life") != null) {
                        goodsVO.setValidityDay((Integer) jsonMap.get("shelf_life"));
                    }
                    goodsVO.setIsBatch((String) jsonMap.get("batch_management_flag"));
                    goodsVO.setIsValidity((String) jsonMap.get("shelf_life_management_flag"));

                    String goodsId = java.util.UUID.randomUUID().toString().replaceAll("-", "");
                    List<GoodsVO> goodsVOList = findPage("selectGoodsByGoodsCodeEntId", goodsVO);
                    if (goodsVOList != null && goodsVOList.size() > 0) {
                        goodsId = goodsVOList.get(0).getGoodsId();
                        goodsVO.setGoodsId(goodsId);
                        goodsDAO.update(goodsVO);
                    } else {
                        goodsVO.setGoodsId(goodsId);
                        goodsVO.setCreateTime(new Date());
                        goodsDAO.insert(goodsVO);
                    }

                    // GoodsSku表处理
                    GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
                    goodsSkuVO.setSkuMCode((String) jsonMap.get("mdm_code"));
                    goodsSkuVO.setSkuCode((String) jsonMap.get("barcode"));
                    goodsSkuVO.setBarCode((String) jsonMap.get("barcode"));
                    goodsSkuVO.setSkuName((String) jsonMap.get("sku_name"));
                    goodsSkuVO.setGoodsId(goodsId);
                    goodsSkuVO.setGoodsCode((String) jsonMap.get("goods_code"));
                    goodsSkuVO.setGoodsName((String) jsonMap.get("goods_name"));
                    goodsSkuVO.setEntId(entId);
                    goodsSkuVO.setSalePrice((BigDecimal) jsonMap.get("retail_price"));
                    goodsSkuVO.setGiftsYn((String) jsonMap.get("gift_allowed_flag"));
                    goodsSkuVO.setVirtYn((String) jsonMap.get("virtual_goods_flag"));
                    goodsSkuVO.setRemark((String) jsonMap.get("remark"));
                    goodsSkuVO.setDeleted("n");
                    goodsSkuVO.setUpdateTime(new Date());
                    goodsSkuVO.setStanPurcPrice((BigDecimal) jsonMap.get("taxed_purchase_price"));

                    List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCodeEntId", goodsSkuVO);
                    if (goodsSkuVOList != null && goodsSkuVOList.size() > 0) {
                        goodsSkuVO.setSkuId(goodsSkuVOList.get(0).getSkuId());
                        goodsDAO.updateSku(goodsSkuVO);
                    } else {
                        goodsSkuVO.setSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                        goodsSkuVO.setCreateTime(new Date());
                        goodsDAO.insertSku(goodsSkuVO);
                    }

                }
            }
        }
        return null;
    }

    @Override
    public String isGoodsSnOpen(String goodsId) throws Exception {
        GoodsVO goodsVO = getGoodsById(goodsId);
        if (goodsVO != null) {
            return goodsVO.getIsSn();
        } else {
            return YesNoConst.NO;
        }
    }

    @Override
    public void setGoodsIsSn(String goodsId, String isSn) throws Exception {
        // 如果商品开关未发生变化，就不执行变更
        GoodsVO goods = getGoodsById(goodsId);
        if (isSn.equals(goods.getIsSn())) {
            return;
//            throw new Exception("商品[编号：" + goods.getGoodsCode() + "]不能变更序列号管理状态，原因是：维持原状");
        }

        // 如果开关发生变化，需要先执行校验逻辑，再执行更新
        String result = isSnOpenable(goodsId);
        if (StringUtils.isEmpty(result)) {
            GoodsVO param = new GoodsVO();
            param.setGoodsId(goodsId);
            param.setIsSn(isSn);
            goodsDAO.update(param);
        } else {
            throw new Exception("商品[编号：" + goods.getGoodsCode() + "]不能变更序列号管理状态，原因是："+result);
        }

        // if(YesNoConst.YES.equals(isSn)) {
        // // 如果开关从禁用变成启用，需要先执行校验逻辑，再执行更新
        // if(isSnOpenable(goodsId)) {
        // GoodsVO param = new GoodsVO();
        // param.setGoodsId(goodsId);
        // param.setIsSn(isSn);
        // // 如果开关从启用变为禁用，直接更新开关
        // goodsDAO.update(param);
        // }else {
        // throw new Exception("商品[编号："+goods.getGoodsCode()+"]不能启用序列号管理");
        // }
        // }else if(YesNoConst.NO.equals(isSn)) {
        // GoodsVO param = new GoodsVO();
        // param.setGoodsId(goodsId);
        // param.setIsSn(isSn);
        // // 如果开关从启用变为禁用，直接更新开关
        // goodsDAO.update(param);
        // }else {
        // throw new Exception("参数传递错误，请检查后重试");
        // }

    }

    /**
     * isSnOpenable:商品是否可以开启序列号管理. <br/>
     *
     * @author zhanghao
     * @param goodsId
     *            商品
     * @return true-可以开启；false-不可以开启
     * @throws Exception
     */
    private String isSnOpenable(String goodsId) throws Exception {
        String returnMsg = snOpenableValidator.doValid(goodsId);
        if (!StringUtils.isNotEmpty(returnMsg)) {
            return "";
        } else {
            return returnMsg;
        }
    }
}
